home *** CD-ROM | disk | FTP | other *** search
/ Mac-Source 1994 July / Mac-Source_July_1994.iso / C and C++ / Compilers⁄Interps / kevoSource / files.c < prev    next >
Text File  |  1993-03-13  |  4KB  |  157 lines
  1. /* Kevo -- a prototype-based object-oriented language */
  2. /* (c) Antero Taivalsaari 1991-1993                   */
  3. /* Some parts (c) Antero Taivalsaari 1986-1988           */
  4. /* files.c: file management internals                     */
  5.  
  6. /* 
  7.     Kevo supports very flexible Unix-like I/O redirection. 
  8.     Every task in the system can have its own input and output files.
  9.     Files operate in a stack-like manner, so that previous I/O
  10.     redirection will be stacked when a new file is opened.
  11. */
  12.  
  13. /*
  14.     Note that these operations are actually not quite as simple as they look,
  15.     because files are task-specific and references to them are macros rather
  16.     than variables.
  17. */
  18.  
  19. #include "global.h"
  20.  
  21. /* ----------------------------------------------------------------------- */
  22.  
  23. /* initFiles(): initialize standard files */
  24. /* If file == 0, I/O is directed to a task-specific window.            */
  25. /* If file == stdout or confile, I/O is directed to console file.    */
  26. /* Otherwise I/O goes to the designated file.                        */
  27.  
  28. void initFiles()
  29. {
  30.   infile = 0;
  31.   outfile = 0;
  32.   errfile = 0;
  33.   confile = stdout;
  34. }
  35.  
  36.  
  37. /* Push the current input file to the task-specific input file stack, */
  38. /* growing the size of the stack if needed, and redirect input to the */
  39. /* given file (which is assumed to be open). */
  40.  
  41. void pushToIFS(file)
  42. FILE* file;
  43. {
  44.   int size;
  45.     if (infileSp >= (size = infileSSize)) {
  46.         /* Allocate space for two more files in the input file stack */
  47.         resizeClosure((*up)->infileStack, size+2);
  48.     }
  49.     infileStk[infileSp++] = (int)infile;
  50.       infile = file;
  51. }
  52.  
  53.  
  54. /* Push the current input file to the task-specific file stack, and  */
  55. /* open a new file for reading instead (given a file name). */
  56.  
  57. void pushInfile(fileName)
  58. char* fileName;
  59. {
  60.   FILE* file;
  61.  
  62.     if ((file = fopen(fileName, "r")) == NIL) {
  63.         fprintf(confile, "== File error (cannot open for reading)."); showTaskID();
  64.         if (!supervisor) {
  65.             ownPrintf("-- Cannot open file '%s' for reading", fileName);
  66.             execute((*up)->errorVector);
  67.         }
  68.         ownLongJmp();
  69.       }
  70.       else pushToIFS(file);
  71. }
  72.  
  73.   
  74. /* Close the current input file and return to the previous one. */
  75. /* Do not close 'stdin', though. */
  76.  
  77. void popInfile()
  78. {
  79.     if (infileSp > 0) {
  80.           FILE* file = infile;
  81.           if (file && file != stdin) { 
  82.               if (fclose(file)) {
  83.                   fprintf(confile, "== File error (cannot close input)."); showTaskID();
  84.                    if (!supervisor) {
  85.                        ownPrintf("-- Cannot close input file");
  86.                        execute((*up)->errorVector);
  87.                 }
  88.                 ownLongJmp();
  89.             }
  90.           }
  91.         infile = (FILE*)(infileStk[--infileSp]);
  92.       }
  93. }
  94.  
  95.  
  96. /* Push the current output file to the task-specific output file stack, */
  97. /* growing the size of the stack is needed, and redirect output to the */
  98. /* given file instead (which is assumed to be open) */
  99.  
  100. void pushToOFS(file)
  101. FILE* file;
  102. {
  103.     int size;
  104.     if (outfileSp >= (size = outfileSSize)) {
  105.         /* Allocate space for two more files in the output file stack */
  106.         resizeClosure((*up)->outfileStack, size+2);
  107.     }
  108.     outfileStk[outfileSp++] = (int)outfile;
  109.       outfile = file;
  110. }
  111.  
  112.  
  113.  
  114. /* Push the current output file to the task-specific file stack, and  */
  115. /* open a new file for writing or appending instead (given a file name */
  116. /* and writing mode ("w" = write, "a" = append)) */
  117.  
  118. void pushOutfile(fileName, mode)
  119. char* fileName;
  120. char* mode;
  121. {
  122.   FILE* file;
  123.  
  124.       if ((file = fopen(fileName, mode)) == NIL) {
  125.         fprintf(confile, "== File error (cannot open for writing)."); showTaskID();
  126.         if (!supervisor) {
  127.             ownPrintf("-- Cannot open file '%s'", fileName);
  128.             execute((*up)->errorVector);
  129.         }
  130.         ownLongJmp();
  131.       }
  132.       else pushToOFS(file);
  133. }
  134.  
  135.   
  136. /* Close the current output file and return to the previous one */
  137. /* Do not close stdout or stderr, though. */
  138.  
  139. void popOutfile()
  140. {
  141.      if (outfileSp > 0) {
  142.           FILE* file = outfile;
  143.         if (file && file != stdout && file != stderr) {
  144.               if (fclose(file)) {
  145.                 fprintf(confile, "== File error (cannot close output)."); showTaskID();
  146.                   if (!supervisor) {
  147.                       ownPrintf("-- Cannot close output file");
  148.                       execute((*up)->errorVector);
  149.                   }
  150.                   ownLongJmp();
  151.               }
  152.         }
  153.         outfile = (FILE*)(outfileStk[--outfileSp]);
  154.     }
  155. }
  156.  
  157.